package com.hao.study.controller;

import com.github.pagehelper.PageInfo;
import com.hao.study.common.APIResponse;
import com.hao.study.common.ResponeCode;
import com.hao.study.entity.User;
import com.hao.study.permission.Access;
import com.hao.study.permission.AccessLevel;
import com.hao.study.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

/**
 * @author: author
 * @description:    用户
 * @date: 2024/6/5 15:29
 * @version: 1.0
 */
@Api(tags={"用户操作接口"})
@RequestMapping("/user")
@RestController
public class UserController {
    private final static Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    UserService userService;

    String salt = "abcd1234";

    @Value("${File.uploadPath}")
    private String uploadPath;

    /**
     * 根据关键字列出用户列表。
     *
     * @param keyword 用于筛选用户的关键字。
     * @return 包含用户列表的API响应。
     */
    @ApiOperation(value = "分页查询功能")
    @ApiImplicitParam(name = "keyword",value = "name关键词",required = false)
    @GetMapping(value = "/keyword")
    public APIResponse keyword(@RequestParam(defaultValue = "1") Integer pageNum,
                               @RequestParam(defaultValue = "10") Integer pageSize,
                               @RequestParam String keyword){
        PageInfo<User> userPageInfo = userService.getUsersList(pageNum, pageSize,keyword);
        return new APIResponse(ResponeCode.SUCCESS,userPageInfo);
    }
    @ApiOperation(value = "分页获取用户列表")
    @GetMapping(value = "/list")
    public APIResponse list(@RequestParam(defaultValue = "1") Integer pageNum,
                            @RequestParam(defaultValue = "10") Integer pageSize){
        System.out.println(pageSize+" "+pageNum);
        PageInfo<User> userPageInfo = userService.selcetPage(pageNum, pageSize);
        System.out.println(userPageInfo);
        return new APIResponse(ResponeCode.SUCCESS,userPageInfo);
    }
    /**
     * 获取指定用户的详细信息。
     *
     * @param userId 指定用户的ID。
     * @return 包含用户详细信息的API响应。
     */
    @ApiOperation(value = "获取用户详细信息")
    @GetMapping(value = "/detail")
    public APIResponse detail(String userId){
        User user =  userService.getUserDetail(userId);
        return new APIResponse(ResponeCode.SUCCESS, "查询成功", user);
    }
    // 后台用户登录
    @ApiOperation(value = "后台用户登录")
    @PostMapping("/login")
    public APIResponse login(@RequestBody User user, HttpServletRequest request){
//        // 从 session 中获取之前保存的验证码文本
//        String sessionCaptcha = (String) request.getSession().getAttribute("CAPTCHA");
//        System.out.println(sessionCaptcha);
//        // 清除 session 中的验证码，防止重复使用
//        request.getSession().removeAttribute("CAPTCHA");
//
//        // 验证验证码
//        if (sessionCaptcha == null || !sessionCaptcha.equalsIgnoreCase(user.getCaptchaText())) {
//            return new APIResponse<>(ResponeCode.FAIL, "验证码错误");
//        }


        user.setPassword(DigestUtils.md5DigestAsHex((user.getPassword()+salt).getBytes()));
        User responseUser=userService.getAdminUser(user);
        logger.info(String.valueOf(user));
        if (responseUser!=null){
            return new APIResponse<>(ResponeCode.SUCCESS,"查询成功",responseUser);
        }else {
            return new APIResponse<>(ResponeCode.FAIL,"用户名或密码错误");
        }
    }
    //普通用户登录
    @ApiOperation(value = "普通用户登录")
    @PostMapping("/userLogin")
    public APIResponse userLogin(@RequestBody User user){
        user.setPassword(DigestUtils.md5DigestAsHex((user.getPassword()+salt).getBytes()));
        User responseUser=userService.getAdminUser(user);
        if (responseUser!=null){
            return new APIResponse<>(ResponeCode.SUCCESS,"查询成功",responseUser);
        }else {
            return new APIResponse<>(ResponeCode.FAIL,"用户名或密码错误");
        }
    }
    // 普通用户注册
    @ApiOperation(value = "普通用户注册")
    @PostMapping("/userRegister")
    @Transactional
    public APIResponse userRegister(@RequestBody User user) throws IOException {
        if(!StringUtils.isEmpty(user.getUsername())
                &&!StringUtils.isEmpty(user.getPassword())
                &&!StringUtils.isEmpty(user.getRePassword)){
            // 查重
            if (userService.getUserByUserName(user.getUsername())!=null){
                return new APIResponse<>(ResponeCode.FAIL,"用户名重复");
            }
            //验证密码
            if (user.getPassword()!=user.getGetRePassword()){
                return new APIResponse<>(ResponeCode.FAIL,"密码不一致");
            }
            //md5加密
            String md5Str = DigestUtils.md5DigestAsHex((user.getPassword() + salt).getBytes());
            //设置密码
            user.setPassword(md5Str);
            md5Str=DigestUtils.md5DigestAsHex((user.getUsername()+salt).getBytes());
            //设置token
            user.setToken(md5Str);
//            //保存头像文件
//            String avatar = saveAvatar(user);
//            if (!StringUtils.isEmpty(avatar)){
//                user.setAvatar(avatar);
//            }
            //设置角色
            user.setRole(String.valueOf(User.NormalUser));
            //设置状态
            user.setStatus("0");
            user.setCreateTime(String.valueOf(System.currentTimeMillis()));
            userService.createUser(user);
            return new APIResponse<>(ResponeCode.SUCCESS,"创建成功");
        }
        return new APIResponse<>(ResponeCode.FAIL,"创建失败");
    }


    //创建账号
    @ApiOperation(value = "创建账号")
    @Access(level = AccessLevel.ADMIN)
    @PostMapping("/create")
    @Transactional
    public APIResponse create(@RequestBody User user) throws IOException {
        if (!StringUtils.isEmpty(user.getUsername()) || !StringUtils.isEmpty(user.getPassword())) {
            // 查重
            if(userService.getUserByUserName(user.getUsername()) != null) {
                return new APIResponse(ResponeCode.FAIL, "用户名重复");
            }
            String md5Str = DigestUtils.md5DigestAsHex((user.getPassword() + salt).getBytes());
            // 设置密码
            user.setPassword(md5Str);
            md5Str = DigestUtils.md5DigestAsHex((user.getUsername() + salt).getBytes());
            // 设置token
            user.setToken(md5Str);
            user.setCreateTime(String.valueOf(System.currentTimeMillis()));

//            String avatar = saveAvatar(user);
//            if(!StringUtils.isEmpty(avatar)) {
//                user.setAvatar(avatar);
//            }
            if (user.getRole() == null){
                user.setRole(String.valueOf(AccessLevel.LOGIN));
            }else {
                if (user.getRole().equals(String.valueOf(AccessLevel.ADMIN))){
                    user.setRole(String.valueOf(AccessLevel.ADMIN));
                }else {
                    user.setRole(String.valueOf(AccessLevel.LOGIN));
                }
            }
            userService.createUser(user);
            return new APIResponse(ResponeCode.SUCCESS, "创建成功");
        }
        return new APIResponse(ResponeCode.FAIL, "创建失败");
    }

    //删除
    @ApiOperation(value = "删除用户")
    @Access(level = AccessLevel.ADMIN)
    @DeleteMapping("/delete/{id}")
    public APIResponse delete(@PathVariable Integer id){
        System.out.println("ids==="+id);
        userService.deleteUser(id);
        return new APIResponse<>(ResponeCode.SUCCESS,"删除成功");
    }
    //批量删除
    @ApiOperation(value = "批量删除")
    @Access(level = AccessLevel.ADMIN)
    @DeleteMapping("/delList")
    public APIResponse delList(@RequestBody List<Integer> ids){
        System.out.println("ids===" + ids);
        for (Integer id : ids) {
            userService.deleteUser(id);
        }
        return new APIResponse<>(ResponeCode.SUCCESS, "删除成功");
    }

    /**
     * 更新用户信息。
     * 该方法接收一个User对象，其中可能包含用户想要更新的信息，如用户名、邮箱等。
     * 注意，该方法不允许更新用户的密码，因此接收到的密码字段将被置为空。
     * 如果用户上传了新头像，将会保存头像并更新用户头像链接。
     * 最后，更新用户信息并返回一个表示操作成功的响应。
     *
     * @param user 包含待更新用户信息的对象。
     * @return 表示操作结果的APIResponse对象，其中包含成功代码和消息。
     * @throws IOException 如果保存头像时发生IO异常。
     */
    @ApiOperation(value = "更新用户信息")
    @Access(level = AccessLevel.ADMIN)
    @PostMapping("/update")
    @Transactional
    public APIResponse update(@RequestBody User user) throws IOException {

//        // 保存上传的头像，如果成功返回头像链接，否则返回空
//        String avatar = saveAvatar(user);
//        // 如果头像链接不为空，更新用户的头像链接
//        if(!StringUtils.isEmpty(avatar)) {
//            user.setAvatar(avatar);
//        }
        // 调用userService更新用户信息
        userService.updateUser(user);
        // 打印更新后的用户信息，用于调试
        System.out.println(user);
        // 返回表示操作成功的响应
        return new APIResponse<>(ResponeCode.SUCCESS,"更新成功");
    }

    @ApiOperation(value = "普通用户更新信息")
    @Access(level = AccessLevel.LOGIN)
    @PostMapping("/updateUserInfo")
    @Transactional
    public APIResponse updateUserInfo(@RequestBody User user) throws IOException {
        User tmpUser=userService.getUserDetail(user.getId());
        if (tmpUser.getRole().equals(String.valueOf(User.NormalUser))){
            //不能改用户名密码 和权限
            user.setUsername(null);
            user.setPassword(null);
            user.setRole(String.valueOf(User.NormalUser));
//            // 保存上传的头像，如果成功返回头像链接，否则返回空
//            String avatar = saveAvatar(user);
//            // 如果头像链接不为空，更新用户的头像链接
//            if(!StringUtils.isEmpty(avatar)) {
//                user.setAvatar(avatar);
//            }
            userService.updateUser(user);
            return new APIResponse<>(ResponeCode.SUCCESS,"更新成功");
        }else{
            return new APIResponse<>(ResponeCode.FAIL,"非法操作");
        }
    }
    /**
     * 更新用户密码的接口。
     * 需要用户登录才能访问，通过POST请求方式提交新旧密码。
     * 使用事务确保密码更新操作的原子性。
     *
     * @param userId 用户ID，用于查找用户信息。
     * @param password 当前密码，用于验证用户身份。
     * @param newPassword 新密码，经过验证后将替换当前密码。
     * @return 返回操作结果，成功或失败，并附带相应信息。
     * @throws IOException 如果发生IO异常。
     */
    @ApiOperation(value = "普通用户更新密码")
    @Access(level = AccessLevel.LOGIN)
    @PostMapping("/updatePwd")
    @Transactional
    public APIResponse updatePwd(@RequestParam String userId, @RequestParam String password,@RequestParam String newPassword) throws IOException {
        // 根据用户ID获取用户详细信息
        User user = userService.getUserDetail(userId);
        // 检查用户角色，仅普通用户允许修改密码
        if (user.getRole().equals(String.valueOf(User.NormalUser))) {
            // 对当前密码进行MD5加密，与数据库中存储的密码进行比较
            String md5Pwd = DigestUtils.md5DigestAsHex((password + salt).getBytes());
            if (user.getPassword().equals(md5Pwd)) {
                // 如果当前密码正确，对新密码进行MD5加密，并更新到用户对象中
                user.setPassword(DigestUtils.md5DigestAsHex((newPassword + salt).getBytes()));
                // 通过用户服务更新用户对象，完成密码修改
                userService.updateUser(user);
            } else {
                // 如果当前密码验证失败，返回失败响应，提示原密码错误
                return new APIResponse(ResponeCode.FAIL, "原密码错误");
            }
            // 密码更新成功，返回成功响应
            return new APIResponse(ResponeCode.SUCCESS, "更新成功");
        } else {
            // 非普通用户尝试修改密码，返回失败响应，提示非法操作
            return new APIResponse(ResponeCode.FAIL, "非法操作");
        }
    }

//    public String saveAvatar(User user) throws IOException {
//        MultipartFile file=user.getAvatarFile();
//        String newFileName=null;
//        if (file!=null&&!file.isEmpty()){
//            //存文件
//            String oldFileName=file.getOriginalFilename();
//            String randomStr= UUID.randomUUID().toString();
//            newFileName=randomStr+oldFileName.substring(oldFileName.lastIndexOf("."));
//            //${File.uploadPath}/avatar/randomStr+oldFileName
//            String filePatch=uploadPath+ File.separator+"avatar"+File.separator+newFileName;
//            File destFile=new File(filePatch);
//            if(!destFile.getParentFile().exists()){
//                destFile.getParentFile().mkdirs();
//            }
//            //它会将file的内容复制到destFile中，覆盖原有的内容。如果destFile不存在，则会创建一个新的文件。
//            file.transferTo(destFile);
//        }
//        if (!StringUtils.isEmpty(newFileName)){
//            user.setAvatar(newFileName);
//        }
//        return newFileName;
//    }
}
